/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package miniprojet.Models;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Ouvre un fichier, le lit et decode en divisant le canaux du piste
 * À partir d'un piste, genere le flus d'octets que sera mis sur la sortie audio 
 * @author cynthia
 */
public class EncodeurWav implements Encodeur{
//    class DonneeWav extends Chunk
//    {
//        private int offset;
//        private int size;
//        private String description;
//        private int valeur;
//
//        public DonneeWav(int offset, int size, String description, int valeur) {
//            this.offset = offset;
//            this.size = size;
//            this.description = description;
//            this.valeur = valeur;
//        }
//        
//        public int nextOffset()
//        {
//            return offset + size;
//        }
//    }
//
//    class Chunk
//    {
//        ArrayList<Chunk> donnes;
//        
//        
//    }
//    
//    public void enteteWav(int tailleFichier)
//    {
//        Chunk entete = new Chunk();
//        entete.donnes.add(new DonneeWav(0x00, 4, "Chunk ID", 0x52494646));        
//        entete.donnes.add(new DonneeWav(0x04, 4, "Chunk Data Size", tailleFichier - 8));
//        entete.donnes.add(new DonneeWav(0x00, 4, "RIFF Type", 0x57415645));
//        
//    }
//    private Chunk chunks;
    private FileInputStream file;
    
    private byte[] chunkID;
    private byte[] chunkSize;
    private byte[] format;
    private byte[] subChunk1ID;
    private byte[] subChunk1Size;
    private byte[] audioFormat;
    private byte[] numChannels;
    private byte[] sampleRate;
    private byte[] byteRate ;
    private byte[] blockAlign;
    private byte[] bitsPerSample;
    private byte[] subChunk2ID;
    private byte[] subChunk2Size;
    private byte[] data;
    
    private ArrayList<Byte> entete;
    
    @Override
    public ArrayList<Byte> coder(Piste piste) {
        ArrayList<Byte> flux = new ArrayList<Byte>();
        
        for(Byte octet : piste.getEntete())
        {
            flux.add(octet);
        }
        for(Byte octet : piste.getCanaux())
        {
            
        }
        
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Décodage d'un fichier audio Wav
     * @param file données récupérés d'un fichier
     * @return Piste contenant les canaux décodés de ce fichier
     */
    @Override
    public Piste decoder(String fileName) {
        try {
            this.file = new FileInputStream(fileName);
        } catch (FileNotFoundException ex) {
            Logger.getLogger(EncodeurWav.class.getName()).log(Level.SEVERE, null, ex);
        }
        try {
            entete = new ArrayList<Byte>();
            
            this.chunkID = getBytes(4);
            this.chunkSize = getBytes(4);
            this.format = getBytes(4);
            this.subChunk1ID = getBytes(4);
            this.subChunk1Size = getBytes(4);
            this.audioFormat = getBytes(2);
            this.numChannels = getBytes(2);
            this.sampleRate = getBytes(4);
            this.byteRate = getBytes(4);
            this.blockAlign = getBytes(4);
            this.bitsPerSample = getBytes(2);
            this.subChunk2ID = getBytes(4);
            this.subChunk2Size = getBytes(4);
            
            int nC1 = (int)this.numChannels[0];
            nC1 = nC1<<8;
            int nC2 = (int)this.numChannels[1];
            int nC = nC1+nC2;
            Piste piste = new Piste(nC);
            
            piste.setEntete(this.entete);
            this.getChannelBytes(piste);
            
            
        } catch (IOException ex) {
            Logger.getLogger(EncodeurWav.class.getName()).log(Level.SEVERE, null, ex);
        }
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Lecture du fichier audio, récupération des données
     * @param int size quantité d'octets à lire
     * @return array des octets récupérés
     * @throws IOException 
     */
    private byte[] getBytes(int size) throws IOException {
        byte [] buf = new byte[size];
        int n = file.read(buf);
        if(n==size)
        {
            for(Byte octet : buf)
            {
                this.entete.add(octet);
            }
            return buf;
        }
        throw new UnsupportedOperationException("Not yet implemented");
    }
    private void getChannelBytes(Piste piste) throws IOException
    {
        
        int n = 0;
        do
        {
            byte [] buf = new byte[piste.getNombreCanaux()];
            n = file.read(buf);
            piste.ajouterInfosCanaux(buf);
        }while(n>=0);
        
        
    }
}
